Computers and computer systems have become an integral part of our lives both at home and at work, and their versatility seems limited only by the imagination of the computer programmers and the software engineers that design and program applications for operation on computers. Thus, computers are powerful and nearly indispensable tools capable of managing home finances and controlling complex production processes and equipment, and organizations frequently decide to utilize computer systems to achieve automation. Though the benefits of automation are significant, the computer systems implementing the automation are only as good as the system architects, designers, programmers, integrators, and testers, collectively known as software engineers that develop them. With so much depending on the skills of the software engineers and with the increasing proliferation of computers and computer systems, industry and even society has become dependent on increasingly scarce software engineers for implementation of automation. Indeed, an entire training industry has developed to meet the ever increasing need for skilled software engineers.
When confronted with the task of implementing automation, organizations frequently retain software engineers to develop and implement custom computer systems with custom software. As software engineers develop a custom system, they analyze the system requirements, architect the system, design the software, code the software, integrate the software, test the components and the system and operate and maintain the system. Typically, this is an iterative design process requiring extensive interaction between the software engineers and the subject matter expert (SME) or experts of the organization. As the software engineers and the SME repeatedly go through these iterations, they encounter numerous inefficiencies and problems inherent to the process. In the system analysis and design phases, the SME must work closely with the software engineers to define the problem. Essentially, the SME must convey all relevant knowledge to the software engineers. Obviously, there are many opportunities for miscommunication between the SME and the programmers or simply omission of pertinent information.
After the SME's knowledge is thought to be transferred, the software engineers begin hard designing and coding the software solution, integrate, and test it. The SME typically has no indication of how the project is going until the software engineers return a functioning program to the SME, and upon review, not surprisingly, the program may not completely or accurately accomplish the desired automation. Thus, the SME and software engineers again engage in the transfer of knowledge from the SME to the engineers, and this exchange may take place several times creating what is sometimes called a knowledge acquisition bottleneck. Each time the software engineer learns more from the SME, they must attempt to alter a system design that is already fixed. Depending on the complexity of the system and the quality of the design, this can range from difficult and time consuming to impossible. Thus, the custom design process is fraught with inefficiencies and problems leading, in many cases, to scheduling delays, unexpected cost increases, and perhaps even failure. Additionally, if after several years of use, changes need to be made to the software or system, the software engineers must be brought back, and the same iterative design process is performed. Therefore, custom development is a time intensive, expensive, and risky undertaking.
To avoid the expense and time involved while significantly reducing the risk in custom computer system and software development, many organizations look for software having industry wide applicability. Assuming such software is even available in a given industry, it implements “best practices” for the industry as determined by the software vendors and has limited adaptability and flexibility. Thus, the organization is forced to sacrifice automation of the unique features of its organization to save money. A sometimes less expensive alternative is to equip the SME with software tools such as spreadsheets and database management systems (DBMS). Once the SME learns how to use the software tools, the SME can develop solutions without the aid of a software engineer. However, the capabilities of these software tools are even more limited, and they typically cannot be integrated with other programs and software engineer support. Thus, assuming there is sufficient time and money, the most desirable option is custom development.
To reduce the cost of custom development and increase capabilities, many different programming languages have been developed including object oriented programming languages (OOPL). These OOPL languages have improved the capability and productivity of software engineers but have not reduced our dependence on such computer specialists to develop custom computerized applications. The same is true for computer aided software engineering (CASE) tools, which have given way in popularity to integrated development environments (IDE). These CASE/IDE tools have provided limited productivity improvements to software engineers by providing the capability to create integrated work environments for teams of software engineers and producing code skeletons or outlines. However, these tools are used by software engineers who must still translate requirements from the SME and hard code in the flesh (logic and rules) of the program. Thus, neither CASE/IDE nor OOPL have reduced reliance on software engineers or improved the inefficiencies encountered when transferring knowledge from the SME to software engineers.
Expert systems also provide assistance to software engineers. Generally expert systems perform a task, such as a medical diagnosis, that would otherwise be performed by a human expert. Expert system shells provide the pre-coded expert system components, such as the inference engine, which utilizes conventional backward and forward chaining approaches. However, such expert system inference engines are not versatile enough for applications that are unrelated to what they were originally created for. Further, to implement an expert system shell, a software engineer hard codes in the knowledge, and the software engineer must still work through the knowledge acquisition bottleneck to obtain that knowledge from an expert in the field. Hence, these expert systems are also not scalable across a wide array of knowledge domains without creating enormous complexity.
Thus, a need exists for a software program having a user friendly interface and which enables a SME to develop a scalable custom software solution for a wide variety of complex automation projects, rather than requiring the services of software engineers. Further, a need exists for a software program that can be updated and revised by a SME without assistance from software engineers. More specifically, a need exists for a software program utilizing a model centric strategy providing fluid, that is readily changeable, objects which model problem solution processes in real time.